/*
 * Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package javax.management;

import com.sun.jmx.mbeanserver.Util;
import java.io.InvalidObjectException;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

/**
 * An immutable descriptor.
 *
 * @since 1.6
 */
public class ImmutableDescriptor implements Descriptor {

  private static final long serialVersionUID = 8853308591080540165L;

  /**
   * The names of the fields in this ImmutableDescriptor with their
   * original case.  The names must be in alphabetical order as determined
   * by {@link String#CASE_INSENSITIVE_ORDER}.
   */
  private final String[] names;
  /**
   * The values of the fields in this ImmutableDescriptor.  The
   * elements in this array match the corresponding elements in the
   * {@code names} array.
   */
  private final Object[] values;

  private transient int hashCode = -1;

  /**
   * An empty descriptor.
   */
  public static final ImmutableDescriptor EMPTY_DESCRIPTOR =
      new ImmutableDescriptor();

  /**
   * Construct a descriptor containing the given fields and values.
   *
   * @throws IllegalArgumentException if either array is null, or if the arrays have different
   * sizes, or if a field name is null or empty, or if the same field name appears more than once.
   */
  public ImmutableDescriptor(String[] fieldNames, Object[] fieldValues) {
    this(makeMap(fieldNames, fieldValues));
  }

  /**
   * Construct a descriptor containing the given fields.  Each String
   * must be of the form {@code fieldName=fieldValue}.  The field name
   * ends at the first {@code =} character; for example if the String
   * is {@code a=b=c} then the field name is {@code a} and its value
   * is {@code b=c}.
   *
   * @throws IllegalArgumentException if the parameter is null, or if a field name is empty, or if
   * the same field name appears more than once, or if one of the strings does not contain an {@code
   * =} character.
   */
  public ImmutableDescriptor(String... fields) {
    this(makeMap(fields));
  }

  /**
   * <p>Construct a descriptor where the names and values of the fields
   * are the keys and values of the given Map.</p>
   *
   * @throws IllegalArgumentException if the parameter is null, or if a field name is null or empty,
   * or if the same field name appears more than once (which can happen because field names are not
   * case sensitive).
   */
  public ImmutableDescriptor(Map<String, ?> fields) {
    if (fields == null) {
      throw new IllegalArgumentException("Null Map");
    }
    SortedMap<String, Object> map =
        new TreeMap<String, Object>(String.CASE_INSENSITIVE_ORDER);
    for (Map.Entry<String, ?> entry : fields.entrySet()) {
      String name = entry.getKey();
      if (name == null || name.equals("")) {
        throw new IllegalArgumentException("Empty or null field name");
      }
      if (map.containsKey(name)) {
        throw new IllegalArgumentException("Duplicate name: " + name);
      }
      map.put(name, entry.getValue());
    }
    int size = map.size();
    this.names = map.keySet().toArray(new String[size]);
    this.values = map.values().toArray(new Object[size]);
  }

  /**
   * This method can replace a deserialized instance of this
   * class with another instance.  For example, it might replace
   * a deserialized empty ImmutableDescriptor with
   * {@link #EMPTY_DESCRIPTOR}.
   *
   * @return the replacement object, which may be {@code this}.
   * @throws InvalidObjectException if the read object has invalid fields.
   */
  private Object readResolve() throws InvalidObjectException {

    boolean bad = false;
    if (names == null || values == null || names.length != values.length) {
      bad = true;
    }
    if (!bad) {
      if (names.length == 0 && getClass() == ImmutableDescriptor.class) {
        return EMPTY_DESCRIPTOR;
      }
      final Comparator<String> compare = String.CASE_INSENSITIVE_ORDER;
      String lastName = ""; // also catches illegal null name
      for (int i = 0; i < names.length; i++) {
        if (names[i] == null ||
            compare.compare(lastName, names[i]) >= 0) {
          bad = true;
          break;
        }
        lastName = names[i];
      }
    }
    if (bad) {
      throw new InvalidObjectException("Bad names or values");
    }

    return this;
  }

  private static SortedMap<String, ?> makeMap(String[] fieldNames,
      Object[] fieldValues) {
    if (fieldNames == null || fieldValues == null) {
      throw new IllegalArgumentException("Null array parameter");
    }
    if (fieldNames.length != fieldValues.length) {
      throw new IllegalArgumentException("Different size arrays");
    }
    SortedMap<String, Object> map =
        new TreeMap<String, Object>(String.CASE_INSENSITIVE_ORDER);
    for (int i = 0; i < fieldNames.length; i++) {
      String name = fieldNames[i];
      if (name == null || name.equals("")) {
        throw new IllegalArgumentException("Empty or null field name");
      }
      Object old = map.put(name, fieldValues[i]);
      if (old != null) {
        throw new IllegalArgumentException("Duplicate field name: " +
            name);
      }
    }
    return map;
  }

  private static SortedMap<String, ?> makeMap(String[] fields) {
    if (fields == null) {
      throw new IllegalArgumentException("Null fields parameter");
    }
    String[] fieldNames = new String[fields.length];
    String[] fieldValues = new String[fields.length];
    for (int i = 0; i < fields.length; i++) {
      String field = fields[i];
      int eq = field.indexOf('=');
      if (eq < 0) {
        throw new IllegalArgumentException("Missing = character: " +
            field);
      }
      fieldNames[i] = field.substring(0, eq);
      // makeMap will catch the case where the name is empty
      fieldValues[i] = field.substring(eq + 1);
    }
    return makeMap(fieldNames, fieldValues);
  }

  /**
   * <p>Return an {@code ImmutableDescriptor} whose contents are the union of
   * the given descriptors.  Every field name that appears in any of
   * the descriptors will appear in the result with the
   * value that it has when the method is called.  Subsequent changes
   * to any of the descriptors do not affect the ImmutableDescriptor
   * returned here.</p>
   *
   * <p>In the simplest case, there is only one descriptor and the
   * returned {@code ImmutableDescriptor} is a copy of its fields at the
   * time this method is called:</p>
   *
   * <pre>
   * Descriptor d = something();
   * ImmutableDescriptor copy = ImmutableDescriptor.union(d);
   * </pre>
   *
   * @param descriptors the descriptors to be combined.  Any of the descriptors can be null, in
   * which case it is skipped.
   * @return an {@code ImmutableDescriptor} that is the union of the given descriptors.  The
   * returned object may be identical to one of the input descriptors if it is an
   * ImmutableDescriptor that contains all of the required fields.
   * @throws IllegalArgumentException if two Descriptors contain the same field name with different
   * associated values.  Primitive array values are considered the same if they are of the same type
   * with the same elements.  Object array values are considered the same if {@link
   * Arrays#deepEquals(Object[], Object[])} returns true.
   */
  public static ImmutableDescriptor union(Descriptor... descriptors) {
    // Optimize the case where exactly one Descriptor is non-Empty
    // and it is immutable - we can just return it.
    int index = findNonEmpty(descriptors, 0);
    if (index < 0) {
      return EMPTY_DESCRIPTOR;
    }
    if (descriptors[index] instanceof ImmutableDescriptor
        && findNonEmpty(descriptors, index + 1) < 0) {
      return (ImmutableDescriptor) descriptors[index];
    }

    Map<String, Object> map =
        new TreeMap<String, Object>(String.CASE_INSENSITIVE_ORDER);
    ImmutableDescriptor biggestImmutable = EMPTY_DESCRIPTOR;
    for (Descriptor d : descriptors) {
      if (d != null) {
        String[] names;
        if (d instanceof ImmutableDescriptor) {
          ImmutableDescriptor id = (ImmutableDescriptor) d;
          names = id.names;
          if (id.getClass() == ImmutableDescriptor.class
              && names.length > biggestImmutable.names.length) {
            biggestImmutable = id;
          }
        } else {
          names = d.getFieldNames();
        }
        for (String n : names) {
          Object v = d.getFieldValue(n);
          Object old = map.put(n, v);
          if (old != null) {
            boolean equal;
            if (old.getClass().isArray()) {
              equal = Arrays.deepEquals(new Object[]{old},
                  new Object[]{v});
            } else {
              equal = old.equals(v);
            }
            if (!equal) {
              final String msg =
                  "Inconsistent values for descriptor field " +
                      n + ": " + old + " :: " + v;
              throw new IllegalArgumentException(msg);
            }
          }
        }
      }
    }
    if (biggestImmutable.names.length == map.size()) {
      return biggestImmutable;
    }
    return new ImmutableDescriptor(map);
  }

  private static boolean isEmpty(Descriptor d) {
    if (d == null) {
      return true;
    } else if (d instanceof ImmutableDescriptor) {
      return ((ImmutableDescriptor) d).names.length == 0;
    } else {
      return (d.getFieldNames().length == 0);
    }
  }

  private static int findNonEmpty(Descriptor[] ds, int start) {
    for (int i = start; i < ds.length; i++) {
      if (!isEmpty(ds[i])) {
        return i;
      }
    }
    return -1;
  }

  private int fieldIndex(String name) {
    return Arrays.binarySearch(names, name, String.CASE_INSENSITIVE_ORDER);
  }

  public final Object getFieldValue(String fieldName) {
    checkIllegalFieldName(fieldName);
    int i = fieldIndex(fieldName);
    if (i < 0) {
      return null;
    }
    Object v = values[i];
    if (v == null || !v.getClass().isArray()) {
      return v;
    }
    if (v instanceof Object[]) {
      return ((Object[]) v).clone();
    }
    // clone the primitive array, could use an 8-way if/else here
    int len = Array.getLength(v);
    Object a = Array.newInstance(v.getClass().getComponentType(), len);
    System.arraycopy(v, 0, a, 0, len);
    return a;
  }

  public final String[] getFields() {
    String[] result = new String[names.length];
    for (int i = 0; i < result.length; i++) {
      Object value = values[i];
      if (value == null) {
        value = "";
      } else if (!(value instanceof String)) {
        value = "(" + value + ")";
      }
      result[i] = names[i] + "=" + value;
    }
    return result;
  }

  public final Object[] getFieldValues(String... fieldNames) {
    if (fieldNames == null) {
      return values.clone();
    }
    Object[] result = new Object[fieldNames.length];
    for (int i = 0; i < fieldNames.length; i++) {
      String name = fieldNames[i];
      if (name != null && !name.equals("")) {
        result[i] = getFieldValue(name);
      }
    }
    return result;
  }

  public final String[] getFieldNames() {
    return names.clone();
  }

  /**
   * Compares this descriptor to the given object.  The objects are equal if
   * the given object is also a Descriptor, and if the two Descriptors have
   * the same field names (possibly differing in case) and the same
   * associated values.  The respective values for a field in the two
   * Descriptors are equal if the following conditions hold:
   *
   * <ul>
   * <li>If one value is null then the other must be too.</li>
   * <li>If one value is a primitive array then the other must be a primitive
   * array of the same type with the same elements.</li>
   * <li>If one value is an object array then the other must be too and
   * {@link Arrays#deepEquals(Object[], Object[])} must return true.</li>
   * <li>Otherwise {@link Object#equals(Object)} must return true.</li>
   * </ul>
   *
   * @param o the object to compare with.
   * @return {@code true} if the objects are the same; {@code false} otherwise.
   */
  // Note: this Javadoc is copied from javax.management.Descriptor
  //       due to 6369229.
  @Override
  public boolean equals(Object o) {
    if (o == this) {
      return true;
    }
    if (!(o instanceof Descriptor)) {
      return false;
    }
    String[] onames;
    if (o instanceof ImmutableDescriptor) {
      onames = ((ImmutableDescriptor) o).names;
    } else {
      onames = ((Descriptor) o).getFieldNames();
      Arrays.sort(onames, String.CASE_INSENSITIVE_ORDER);
    }
    if (names.length != onames.length) {
      return false;
    }
    for (int i = 0; i < names.length; i++) {
      if (!names[i].equalsIgnoreCase(onames[i])) {
        return false;
      }
    }
    Object[] ovalues;
    if (o instanceof ImmutableDescriptor) {
      ovalues = ((ImmutableDescriptor) o).values;
    } else {
      ovalues = ((Descriptor) o).getFieldValues(onames);
    }
    return Arrays.deepEquals(values, ovalues);
  }

  /**
   * <p>Returns the hash code value for this descriptor.  The hash
   * code is computed as the sum of the hash codes for each field in
   * the descriptor.  The hash code of a field with name {@code n}
   * and value {@code v} is {@code n.toLowerCase().hashCode() ^ h}.
   * Here {@code h} is the hash code of {@code v}, computed as
   * follows:</p>
   *
   * <ul>
   * <li>If {@code v} is null then {@code h} is 0.</li>
   * <li>If {@code v} is a primitive array then {@code h} is computed using
   * the appropriate overloading of {@code java.util.Arrays.hashCode}.</li>
   * <li>If {@code v} is an object array then {@code h} is computed using
   * {@link Arrays#deepHashCode(Object[])}.</li>
   * <li>Otherwise {@code h} is {@code v.hashCode()}.</li>
   * </ul>
   *
   * @return A hash code value for this object.
   */
  // Note: this Javadoc is copied from javax.management.Descriptor
  //       due to 6369229.
  @Override
  public int hashCode() {
    if (hashCode == -1) {
      hashCode = Util.hashCode(names, values);
    }
    return hashCode;
  }

  @Override
  public String toString() {
    StringBuilder sb = new StringBuilder("{");
    for (int i = 0; i < names.length; i++) {
      if (i > 0) {
        sb.append(", ");
      }
      sb.append(names[i]).append("=");
      Object v = values[i];
      if (v != null && v.getClass().isArray()) {
        String s = Arrays.deepToString(new Object[]{v});
        s = s.substring(1, s.length() - 1); // remove [...]
        v = s;
      }
      sb.append(String.valueOf(v));
    }
    return sb.append("}").toString();
  }

  /**
   * Returns true if all of the fields have legal values given their
   * names.  This method always returns true, but a subclass can
   * override it to return false when appropriate.
   *
   * @return true if the values are legal.
   * @throws RuntimeOperationsException if the validity checking fails. The method returns false if
   * the descriptor is not valid, but throws this exception if the attempt to determine validity
   * fails.
   */
  public boolean isValid() {
    return true;
  }

  /**
   * <p>Returns a descriptor which is equal to this descriptor.
   * Changes to the returned descriptor will have no effect on this
   * descriptor, and vice versa.</p>
   *
   * <p>This method returns the object on which it is called.
   * A subclass can override it
   * to return another object provided the contract is respected.
   *
   * @throws RuntimeOperationsException for illegal value for field Names or field Values. If the
   * descriptor construction fails for any reason, this exception will be thrown.
   */
  @Override
  public Descriptor clone() {
    return this;
  }

  /**
   * This operation is unsupported since this class is immutable.  If
   * this call would change a mutable descriptor with the same contents,
   * then a {@link RuntimeOperationsException} wrapping an
   * {@link UnsupportedOperationException} is thrown.  Otherwise,
   * the behavior is the same as it would be for a mutable descriptor:
   * either an exception is thrown because of illegal parameters, or
   * there is no effect.
   */
  public final void setFields(String[] fieldNames, Object[] fieldValues)
      throws RuntimeOperationsException {
    if (fieldNames == null || fieldValues == null) {
      illegal("Null argument");
    }
    if (fieldNames.length != fieldValues.length) {
      illegal("Different array sizes");
    }
    for (int i = 0; i < fieldNames.length; i++) {
      checkIllegalFieldName(fieldNames[i]);
    }
    for (int i = 0; i < fieldNames.length; i++) {
      setField(fieldNames[i], fieldValues[i]);
    }
  }

  /**
   * This operation is unsupported since this class is immutable.  If
   * this call would change a mutable descriptor with the same contents,
   * then a {@link RuntimeOperationsException} wrapping an
   * {@link UnsupportedOperationException} is thrown.  Otherwise,
   * the behavior is the same as it would be for a mutable descriptor:
   * either an exception is thrown because of illegal parameters, or
   * there is no effect.
   */
  public final void setField(String fieldName, Object fieldValue)
      throws RuntimeOperationsException {
    checkIllegalFieldName(fieldName);
    int i = fieldIndex(fieldName);
    if (i < 0) {
      unsupported();
    }
    Object value = values[i];
    if ((value == null) ?
        (fieldValue != null) :
        !value.equals(fieldValue)) {
      unsupported();
    }
  }

  /**
   * Removes a field from the descriptor.
   *
   * @param fieldName String name of the field to be removed. If the field name is illegal or the
   * field is not found, no exception is thrown.
   * @throws RuntimeOperationsException if a field of the given name exists and the descriptor is
   * immutable.  The wrapped exception will be an {@link UnsupportedOperationException}.
   */
  public final void removeField(String fieldName) {
    if (fieldName != null && fieldIndex(fieldName) >= 0) {
      unsupported();
    }
  }

  static Descriptor nonNullDescriptor(Descriptor d) {
    if (d == null) {
      return EMPTY_DESCRIPTOR;
    } else {
      return d;
    }
  }

  private static void checkIllegalFieldName(String name) {
    if (name == null || name.equals("")) {
      illegal("Null or empty field name");
    }
  }

  private static void unsupported() {
    UnsupportedOperationException uoe =
        new UnsupportedOperationException("Descriptor is read-only");
    throw new RuntimeOperationsException(uoe);
  }

  private static void illegal(String message) {
    IllegalArgumentException iae = new IllegalArgumentException(message);
    throw new RuntimeOperationsException(iae);
  }
}
